#include <iostream>
using namespace std;

/*内存管理
class ListNode{
public:
	ListNode(int val = 0):_val(val),_next(nullptr),_prev(nullptr)
	{
		cout << "val:" << _val<< endl;
	}
	~ListNode(){
		cout << "析构" << endl;
	}
private:
	int _val;
	ListNode* _next;
	ListNode* _prev;
};

int main(){
    //C语言申请动态内存
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = (int*)malloc(sizeof(int) * 10);
    free(p1);
    free(p2);

    // C++申请动态内存
    //int *p3 = new int;
    int *p3 = new int(10);//申请 一个int大小的空间，并初始化成10
    int *p4 = new int[10];//申请10个int大小的空间
    delete p3;
    delete[] p4;

	//malloc和new的区别在在自定义类型中：malloc只会申请空间，
	//而new是申请空间+构造函数
	//delete也同样，释放空间+析构函数
	ListNode *p5 = new ListNode;
    delete p5;

	//malloc和operator new的区别
	//结论：使用方式都一样，处理错误的方式不一样
	//malloc失败返回0，operator new失败抛异常
	//free和operator free没区别，因为失败直接终止程序
	ListNode* L1 = (ListNode*)malloc(sizeof(ListNode));
	ListNode* L2 = (ListNode*)operator new(sizeof(ListNode));

	//new = operator new + 构造
	//delete = operator free + 析构

	//模拟new的行为,下面两行合起来就是new的行为
	ListNode* L3 = (ListNode*)operator new(sizeof(ListNode));
	new(L3)ListNode(10);//构造
	//模拟delete的行为,下面两行合起来就是delete的行为
	L3->~ListNode();
	operator delete(L3);

    return 0;
}
*/

/*模版
//模版——写跟类型无关的代码
//template<typename T>
template<class T>
void Swap(T& s1,T& s2){
	T tmp = s1;
	s1 = s2;
	s2 = tmp;
	cout << s1 << " "<< s2 <<endl;
}


int main(){
	int a= 10,b = 9;
	double c= 10.2,d = 9.1;
	Swap<int>(a, b);
	Swap<double>(c, d);
	//也可以不加<>
	Swap(a, b);

	//上面调用的不是同一个函数，而是经过模版的推演和实例化生成对应类型的函数
	return 0; 
}
*/

//C语言实现一个栈
typedef int STDateType ;
typedef struct Stack_C{
	STDateType* _a;
	int _size;
	int _capacity;
}Stack_C;

void StackInit(Stack_C* ps);
void StackPush(Stack_C* ps,STDateType x);
void StackPop(Stack_C* ps);
void StackDestroy(Stack_C* ps);

//C++实现一个栈
template<class T>
class Stack_CPP{
private:
	T* _a;
	int _size;
	int _capacity;
};

int main(){
	//1.容易忘记初始化和销毁
	//2.没有封装，容易被改变数据
	//3.不能同时定义两个不同类型的栈
	Stack_C st_c;
	//C++优化C的不足
	//1.有构造和析构
	//2.访问限定符
	//3.模版
	Stack_CPP<int> st_cpp;
}